﻿using System;
using System.IO;
using System.Net.Mail;
using System.Xml.Linq;
using MassIntellect.WorkIt;
using System.Net;
using System.Text;

namespace MassIntellect.Pipes
{
    //public class EMailBot
    //{
    //    private long _ProvideMessages = 0;
    //    /// <summary>
    //    /// Прошло сообщений
    //    /// </summary>
    //    public long ProvideMessages
    //    {
    //        get { return _ProvideMessages; }
    //        set
    //        {
    //            _ProvideMessages = value;
    //            OnPropertyChanged("ProvideMessages");
    //        }
    //    }
    //    private long _WaitingMessages;
    //    /// <summary>
    //    /// Ожидающих сообщений
    //    /// </summary>
    //    public long WaitingMessages
    //    {
    //        get
    //        {
    //            return _WaitingMessages;
    //        }
    //        set
    //        {
    //            _WaitingMessages = value;
    //            OnPropertyChanged("WaitingMessages");
    //        }
    //    }
    //    private string _Name = "";
    //    public string Name
    //    {
    //        get { return _Name; }
    //        set
    //        {
    //            _Name = value;
    //            OnPropertyChanged("Name");
    //        }
    //    }

    //    protected Pop3Client pop = null;
    //    protected SmtpClient smtp = null;
    //    public Pop3Client Pop3
    //    { get { return pop; } }
    //    public SmtpClient Smtp
    //    { get { return smtp; } }
    //    public bool IsSender { get { return smtp != null; } }
    //    public bool IsRecipient { get { return pop != null; } }
    //    public EMailBot()
    //    {
    //    }
    //    public EMailBot SetSender(
    //        string Hostname, string UserName, string Pass, string SenderEMail, bool UseSSL, int Port)
    //    {
    //        SmtpClient smtp1 = new SmtpClient(Hostname);
    //        smtp1.EnableSsl = UseSSL;
    //        if (Port > 0)
    //            smtp1.Port = Port;
    //        smtp1.Credentials = new NetworkCredential(UserName, Pass);
    //        FromAddress = SenderEMail;
    //        SetSender(smtp1, SenderEMail);
    //        return this;
    //    }

    //    public EMailBot SetSender(SmtpClient client, string SenderEMail)
    //    {
    //        smtp = client;
    //        FromAddress = SenderEMail;
    //        return this;
    //    }
    //    private string _FromAddress = "";
    //    public string FromAddress
    //    {
    //        get { return _FromAddress; }
    //        set
    //        {
    //            _FromAddress = value;
    //            OnPropertyChanged("FromAddress");
    //        }
    //    }
    //    public EMailBot SetRecipient(
    //        string Hostname, string UserName, string Pass, bool UseSSL, int Port)
    //    {
    //        SetRecipient(new Pop3Client(Hostname, (Port <= 0) ? (UseSSL) ? 995 : 110 : Port, UseSSL, UserName, Pass));
    //        return this;
    //    }
    //    public EMailBot SetRecipient(
    //        Pop3Client client)
    //    {
    //        pop = client;
    //        return this;
    //    }

    //    private bool _Pop3Enabled;
    //    /// <summary>
    //    /// Активность Pop3-клиента
    //    /// </summary>
    //    public bool Pop3Enabled
    //    {
    //        get
    //        {
    //            return _Pop3Enabled;
    //        }
    //        set
    //        {
    //            if (_Pop3Enabled != value)
    //            {
    //                _Pop3Enabled = value;
    //                OnPropertyChanged("Pop3Enabled");
    //            }
    //        }
    //    }

    //    private bool _SmtpEnabled;
    //    /// <summary>
    //    /// Активность Smtp-клиента
    //    /// </summary>
    //    public bool SmtpEnabled
    //    {
    //        get
    //        {
    //            return _SmtpEnabled;
    //        }
    //        set
    //        {
    //            if (_SmtpEnabled != value)
    //            {
    //                _SmtpEnabled = value;
    //                OnPropertyChanged("SmtpEnabled");
    //            }
    //        }
    //    }

    //    private int _MailWindow = 5;
    //    /// <summary>
    //    /// Окно сообщений. Количество обрабатываемых писем за одну сессию связи.
    //    /// </summary>
    //    public int MailWindow
    //    {
    //        get
    //        {
    //            return _MailWindow;
    //        }
    //        set
    //        {
    //            if (value > 0 && value < 1000)
    //                _MailWindow = value;
    //            OnPropertyChanged("MailWindow");
    //        }
    //    }
    //    private string _ViewState;
    //    /// <summary>
    //    /// Описание состояния
    //    /// </summary>
    //    public string ViewState
    //    {
    //        get
    //        {
    //            return _ViewState;
    //        }
    //        set
    //        {
    //            _ViewState = value;
    //            OnPropertyChanged("ViewState");
    //        }
    //    }

    //    public void ForceCheckMailBox()
    //    {
    //        if (IsRecipient && ReceptPack != null)
    //        {
    //            string strk = ViewState;
    //            Log.EchoExt("MailAgent.{0}".goFormat(Name), "Аутентификация...");
    //            ViewState = "Аутентификация";
    //            try
    //            {
    //                pop.Authenticate();
    //            }
    //            catch (Exception ex)
    //            {
    //                Log.AddLineExt(LogLevel.llError, "MailAgent.{0}".goFormat(Name), "Ошибка аутентификации: {0}", ex.Message);
    //                if (Debugger.IsDebugMode)
    //                    ViewState = "Ошибка аутентификации: {0}".goFormat(ex.Message);
    //                else
    //                    ViewState = "Ошибка аутентификации. Обратитесь к администратору.";
    //                return;
    //            }
    //            try
    //            {
    //                pop.Stat();
    //                ViewState = "Получение списка заголовков";
    //                Log.EchoExt("MailAgent.{0}".goFormat(Name), "Получение списка заголовков...");
    //                List<Pop3ListItem> itm = pop.List();
    //                WaitingMessages = itm.Count;
    //                MailMessageEx mme;
    //                MemoryStream mem;
    //                byte[] buffer = new byte[1024];
    //                int readed = 0;
    //                int mailcount = Math.Min(itm.Count, MailWindow);
    //                for (int i = 0; i < mailcount; i++)
    //                {
    //                    ViewState = "Получение писем";
    //                    Log.EchoExt("MailAgent.{0}".goFormat(Name), "Получение писем {0} из {1}. Всего {2}.", i+1, mailcount, WaitingMessages);
    //                    if (StampsReadedMessages.IndexOf(itm[i].Octets) < 0)
    //                    {
    //                        mme = pop.RetrMailMessageEx(itm[i]);
    //                        Log.AddLineExt(LogLevel.llInfo, "MailBot." + Name, "Получено сообщение от {0}. Тема:{1}", mme.From.Address, mme.Subject);
    //                        if (mme.Attachments.Count == 0)
    //                            OnReceptBody(mme.Body,
    //                                mme.From.Address, mme.Subject);
    //                        foreach (Attachment att in mme.Attachments)
    //                        {
    //                            mem = new MemoryStream();
    //                            while ((readed = att.ContentStream.Read(buffer, 0, buffer.Length)) > 0)
    //                                mem.Write(buffer, 0, readed);
    //                            mem.Position = 0;
    //                            OnReceptPack(mem,
    //                                mme.From.Address, (string.IsNullOrEmpty(att.Name)) ? mme.Subject : att.Name);
    //                        }
    //                        pop.Dele(itm[i]);
    //                    }
    //                }
    //            }
    //            catch (Exception ex)
    //            {
    //                Log.AddLineExt(LogLevel.llError, "MailAgent.{0}".goFormat(Name), "Ошибка при обработке почты: {0}", ex.Message);
    //                if (Debugger.IsDebugMode)
    //                    ViewState = "Ошибка при обработке почты [{0}]".goFormat(ex.Message);
    //                else
    //                    ViewState = "Ошибка при обработке почты. Обратитесь к администратору.";
    //                return;
    //            }
    //            finally
    //            {
    //                pop.Quit();
    //            }
    //            ViewState = strk;
    //        }
    //    }

    //    public void CheckMailBox()
    //    {
    //        if (Enabled && ConditionCheck.GetResult())
    //            ForceCheckMailBox();
    //    }

    //    public void SendMessage(string Recipient, string Subject, Attachment att)
    //    {
    //        if (!Recipient.IsEmpty())
    //            SendMessage(new MailAddress(Recipient), Subject, att);
    //    }
    //    public void SendMessage(MailAddress Recipient, string Subject, Attachment att)
    //    {
    //        try
    //        {
    //            MailMessageEx mme = new MailMessageEx();
    //            mme.To.Add(Recipient);
    //            mme.Subject = Subject;
    //            mme.Attachments.Add(att);
    //            mme.From = new MailAddress(FromAddress);
    //            smtp.Send(mme);
    //        }
    //        catch (Exception ex)
    //        {
    //            Log.AddLineExt(LogLevel.llError, "MailBot." + this.Name, "Не удалось отправить сообщение. Описание: {0}", ex.Message);
    //        }
    //    }
    //    public void SendMessage(string Recipient, string Subject, string AttName, XElement att)
    //    {
    //        SendMessage(new MailAddress(Recipient), Subject, new Attachment(
    //                new MemoryStream(
    //                    Encoding.UTF8.GetBytes(att.ToString())), AttName, "text/xml"));
    //    }
    //    public Proc<Stream, string, string> ReceptPack = null;
    //    public Proc<string, string, string> ReceptBody = null;
    //    private void OnReceptPack(Stream xePack, string Sender, string Name)
    //    {
    //        ProvideMessages++;
    //        if (ReceptPack != null)
    //            ReceptPack(xePack, Sender, Name);
    //    }
    //    private void OnReceptBody(string Body, string Sender, string Name)
    //    {
    //        ProvideMessages++;
    //        if (ReceptBody != null)
    //            ReceptBody(Body, Sender, Name);
    //    }

    //    public XElement Serialize()
    //    {
    //        return new XElement("MailBot",
    //            new XElement("Name", Name),
    //            new XElement("Enabled", Enabled),
    //            (!IsRecipient) ? null :
    //            new XElement("Pop3",
    //                new XElement("Enabled", Pop3Enabled),
    //                new XElement("Host", pop.Hostname),
    //                new XElement("Port", pop.Port),
    //                new XElement("SSL", pop.UseSsl),
    //                new XElement("Login", pop.Username),
    //                new XElement("Password", pop.Password),
    //                new XElement("CheckingInterval", CheckingInterval),
    //                new XElement("MailWindow", MailWindow)),
    //            (!IsSender) ? null :
    //            new XElement("Smtp",
    //                new XElement("Enabled", SmtpEnabled),
    //                new XElement("Host", smtp.Host),
    //                new XElement("Port", smtp.Port),
    //                new XElement("SSL", smtp.EnableSsl),
    //                new XElement("Login", ((NetworkCredential)smtp.Credentials).UserName),
    //                new XElement("BackwardAddress", FromAddress),
    //                new XElement("Password", ((NetworkCredential)smtp.Credentials).Password)
    //                        )

    //        );
    //    }
    //    public static EMailBot Deserialize(XElement xe, Log Log)
    //    {
    //        EMailBot emb = null;
    //        if (xe != null)
    //        {
    //            try
    //            {
    //                emb = new EMailBot(Log);
    //                emb.Name = (string)xe.Element("Name");
    //                emb.Enabled = (bool)xe.Element("Enabled");
    //                XElement xes;
    //                if ((xes = xe.Element("Smtp")) != null)
    //                {
    //                    emb.SmtpEnabled = (bool)xes.Element("Enabled");
    //                    emb.SetSender(
    //                        (string)xes.Element("Host"),
    //                        (string)xes.Element("Login"),
    //                        (string)xes.Element("Password"),
    //                        (string)xes.Element("BackwardAddress"),
    //                        (bool)xes.Element("SSL"),
    //                        (int)xes.Element("Port"));
    //                }

    //                if ((xes = xe.Element("Pop3")) != null)
    //                {
    //                    emb.MailWindow = (int)xes.Element("MailWindow");
    //                    emb.CheckingInterval = (int)xes.Element("CheckingInterval");
    //                    emb.Pop3Enabled = (bool)xes.Element("Enabled");
    //                    emb.SetRecipient(
    //                        (string)xes.Element("Host"),
    //                        (string)xes.Element("Login"),
    //                        (string)xes.Element("Password"),
    //                        (bool)xes.Element("SSL"),
    //                        (int)xes.Element("Port"));
    //                }
    //            }
    //            catch (Exception ex)
    //            {
    //                if (Log != null)
    //                    Log.AddLineExt(LogLevel.llError, "MailBotBuilder", "Ошибка при создании почтового агента {0}:{1}", emb.Name, ex.Message);
    //                emb = null;
    //            }
    //        }
    //        return emb;
    //    }

    //    #region Члены INotifyPropertyChanged

    //    public event PropertyChangedEventHandler PropertyChanged;
    //    public void OnPropertyChanged(string e)
    //    {
    //        if (PropertyChanged != null)
    //            PropertyChanged(this, new PropertyChangedEventArgs(e));
    //    }

    //    #endregion

    //    #region ICloneable<EMailBot> Members

    //    public EMailBot Clone()
    //    {
    //        return Deserialize(Serialize(), null);
    //    }

    //    #endregion
    //}

    //public class MailMess
    //{
    //    public static MailMess NullMessage = new MailMess();
    //    public string Sender = "";
    //    public string AttName;
    //    public string Subject;
    //    public Stream Stream = null;
    //    public string Body = "";
    //    public bool IsReaded = false;
    //}

    //public class MailDispatcher : INotifyPropertyChanged, ICollection<EMailBot>, INotifyCollectionChanged
    //{
    //    private int Counter;
    //    private Dispatcher OwnerDispatcher = Dispatcher.CurrentDispatcher;
    //    private SynchronizedCollection<EMailBot> MailBots = new SynchronizedCollection<EMailBot>();

    //    private void ReceivedAttach(Stream xePack, string Sender, string AttName)
    //    {
    //        if (Dispatcher.CurrentDispatcher == OwnerDispatcher)
    //            Attaches.Add(new MailMess { Stream = xePack, Sender = Sender, AttName = AttName });
    //        else
    //            lock (Attaches)
    //            {
    //                Attaches.Add(new MailMess { Stream = xePack, Sender = Sender, AttName = AttName });
    //            }
    //    }
    //    private void ReceivedBody(string body, string Sender, string AttName)
    //    {
    //        if (Dispatcher.CurrentDispatcher == OwnerDispatcher)
    //            Attaches.Add(new MailMess { Body = body, Sender = Sender, AttName = AttName });
    //        else
    //            lock (Attaches)
    //            {
    //                Attaches.Add(new MailMess { Body = body, Sender = Sender, AttName = AttName });
    //            }
    //    }

    //    private List<MailMess> Attaches = new List<MailMess>();
    //    private int _NewMessage = 0;
    //    public int NewMessage
    //    {
    //        get { return _NewMessage; }
    //        private set
    //        {
    //            _NewMessage = value;
    //            OnPropertyChanged(new PropertyChangedEventArgs("NewMessage"));
    //        }
    //    }
    //    private IEnumerable<MailMess> fReadStreamMessages()
    //    {
    //        lock (Attaches)
    //        {
    //            foreach (MailMess item in Attaches)
    //                if (item != MailMess.NullMessage)
    //                {
    //                    yield return item;
    //                    NewMessage--;
    //                }
    //            Attaches.Clear();
    //        }
    //    }
    //    public IEnumerable<MailMess> ReadXmlMessages()
    //    {
    //        byte[] buffer = new byte[2048];
    //        int readed = 0;
    //        MemoryStream mem;
    //        foreach (MailMess item in fReadStreamMessages())
    //        {
    //            if (item.Stream != null)
    //            {
    //                item.Stream.Read(buffer, 0, 2);
    //                item.Stream.Seek(0, SeekOrigin.Begin);
    //                if (new ASCIIEncoding().GetString(buffer, 0, 2) == "PK")
    //                {
    //                    ZipInputStream zis = new ZipInputStream(item.Stream);
    //                    ZipEntry ze = null;
    //                    while ((ze = zis.GetNextEntry()) != null)
    //                    {
    //                        mem = new MemoryStream();
    //                        while ((readed = zis.Read(buffer, 0, buffer.Length)) > 0)
    //                            mem.Write(buffer, 0, readed);
    //                        mem.Position = 0;
    //                        yield return new MailMess { Stream = mem, Sender = item.Sender, AttName = ze.Name };
    //                    }
    //                }
    //                else
    //                    yield return item;
    //            }
    //            else
    //                yield return item;
    //        }
    //    }
    //    public void Tick()
    //    {
    //        foreach (var item in MailBots)
    //            item.CheckMailBox();
    //    }
    //    #region INotifyPropertyChanged Members

    //    public event PropertyChangedEventHandler PropertyChanged;
    //    private void OnPropertyChanged(PropertyChangedEventArgs e)
    //    {
    //        if (PropertyChanged != null)
    //            PropertyChanged(this, e);
    //    }

    //    #endregion

    //    #region ICollection<EMailBot> Members

    //    public void Add(EMailBot item)
    //    {
    //        if (item != null)
    //        {
    //            MailBots.Add(item);
    //            item.ReceptPack += ReceivedAttach;
    //            item.ReceptBody += ReceivedBody;
    //            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item));
    //        }
    //    }

    //    public void Clear()
    //    {
    //        MailBots = new SynchronizedCollection<EMailBot>();
    //        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    //    }

    //    public bool Contains(EMailBot item)
    //    {
    //        return MailBots.Contains(item);
    //    }

    //    public void CopyTo(EMailBot[] array, int arrayIndex)
    //    {
    //        foreach (var item in MailBots)
    //            array[arrayIndex++] = item;
    //    }

    //    public int Count
    //    {
    //        get { return MailBots.Count; }
    //    }

    //    public bool IsReadOnly
    //    {
    //        get { return false; }
    //    }

    //    public bool Remove(EMailBot item)
    //    {
    //        int cnt=0;
    //        foreach (var itm in MailBots)
    //        {
    //            if (itm == item)
    //            {
    //                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, null, item, cnt));
    //                return true;
    //            }
    //            cnt++;
    //        }
    //        return false;
    //    }

    //    #endregion

    //    #region IEnumerable<EMailBot> Members

    //    public IEnumerator<EMailBot> GetEnumerator()
    //    {
    //        return MailBots.GetEnumerator();
    //    }

    //    #endregion

    //    #region IEnumerable Members

    //    IEnumerator IEnumerable.GetEnumerator()
    //    {
    //        return MailBots.GetEnumerator();
    //    }

    //    #endregion

    //    public EMailBot this[int Index]
    //    {
    //        get
    //        {
    //            return MailBots[Index];
    //        }
    //    }

    //    private void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    //    {
    //        if (CollectionChanged != null)
    //            CollectionChanged(this, e);
    //    }

    //    #region INotifyCollectionChanged Members

    //    public event NotifyCollectionChangedEventHandler CollectionChanged;

    //    #endregion
    //}

    //public static class StreamExtension
    //{
    //    public static Stream WriteFromStream(this Stream main, Stream StreamFrom)
    //    {
    //        if (main != null && StreamFrom != null)
    //        {
    //            byte[] buffer = new byte[2048];
    //            int readed;
    //            while ((readed = StreamFrom.Read(buffer, 0, buffer.Length)) > 0)
    //                main.Write(buffer, 0, readed);
    //        }
    //        return main;
    //    }
    //    public static byte[] ToByteArray(this Stream main)
    //    {
    //        byte[] buffer;
    //        if (main != null)
    //        {
    //            buffer = new byte[main.Length];
    //            main.Read(buffer, 0, (int)main.Length);
    //        }
    //        else
    //            buffer = new byte[0];
    //        return buffer;
    //    }
    //}

    ///// <summary>
    ///// Отправка контента на определенный контакт
    ///// </summary>
    //public class MailSender : IWorkFrame, IWorkFrame<XElement, bool>
    //{
    //    public SmtpClient Smtp { get; private set; }

    //    public string BackwardAddress { get; set; }

    //    public MailSender()
    //    {
    //        Id = Guid.NewGuid();
    //    }

    //    public void SendMessage(string Recipient, string Subject, Attachment att)
    //    {
    //        SendMessage(new MailAddress(Recipient), Subject, att);
    //    }
    //    public void SendMessage(string Recipient, string Subject, Attachment att)
    //    {
    //        if (!Recipient.IsEmpty())
    //            SendMessage(new MailAddress(Recipient), Subject, att);
    //    }
    //    public void SendMessage(MailAddress Recipient, string Subject, Attachment att)
    //    {
    //        try
    //        {
    //            MailMessageEx mme = new MailMessageEx();
    //            mme.To.Add(Recipient);
    //            mme.Subject = Subject;
    //            mme.Attachments.Add(att);
    //            mme.From = new MailAddress(FromAddress);
    //            smtp.Send(mme);
    //        }
    //        catch (Exception ex)
    //        {
    //            Log.AddLineExt(LogLevel.llError, "MailBot." + this.Name, "Не удалось отправить сообщение. Описание: {0}", ex.Message);
    //        }
    //    }
    //    public void SendMessage(string Recipient, string Subject, string AttName, XElement att)
    //    {
    //        SendMessage(new MailAddress(Recipient), Subject, new Attachment(
    //                new MemoryStream(
    //                    Encoding.UTF8.GetBytes(att.ToString())), AttName, "text/xml"));
    //    }

    //    #region IWorkFrame Members

    //    public Guid Id { get; set; }

    //    public bool Preserve { get; set; }

    //    public string Name { get; set; }

    //    public bool IsEnabled { get; set; }

    //    public State State { get; set; }

    //    public Condition Condition { get; set; }

    //    public void SetUp(XElement xe)
    //    {

    //    }

    //    public XElement Serialize()
    //    {
    //        return new XElement("MailBot",
    //            new XElement("Name", Name),
    //            new XElement("IsEnabled", IsEnabled),
    //            new XElement("Host", Smtp.Host),
    //            new XElement("Port", Smtp.Port),
    //            new XElement("SSL", Smtp.EnableSsl),
    //            new XElement("Login", ((NetworkCredential)Smtp.Credentials).UserName),
    //            new XElement("BackwardAddress", BackwardAddress),
    //            new XElement("Password", ((NetworkCredential)Smtp.Credentials).Password)
    //        );
    //    }

    //    #endregion
    //}

    public class EMailSender : WorkFrame
    {
        private SmtpClient _Client;
        public SmtpClient Client
        {
            get
            {
                return _Client = _Client ?? new SmtpClient();
            }
            set
            {
                _Client = value;
            }
        }

        [Serialize]
        public string Host
        {
            get { return Client.Host; }
            set { Client.Host = value; }
        }

        [Serialize]
        public int Port
        {
            get { return Client.Port; }
            set { Client.Port = value; }
        }

        private NetworkCredential Credential
        {
            get
            {
                return Client.Credentials as NetworkCredential ?? (NetworkCredential)(Client.Credentials = new NetworkCredential());
            }
        }

        [Serialize]
        public string FromAddress { get; set; }

        [Serialize]
        public string Username
        {
            get
            {
                return Credential.UserName;
            }
            set
            {
                Credential.UserName = value;
            }
        }

        [Serialize]
        public string Password
        {
            get
            {
                return Credential.Password;
            }
            set
            {
                Credential.Password = value;
            }
        }

        [Serialize]
        public bool UseSSL
        {
            get { return Client.EnableSsl; }
            set { Client.EnableSsl = value; }
        }

        public void SendMessage(string Recipient, string Subject, Attachment att)
        {
            if (!Recipient.IsEmpty())
                SendMessage(new MailAddress(Recipient), Subject, att);
        }
        public void SendMessage(MailAddress Recipient, string Subject, Attachment att)
        {
            try
            {
                MailMessageEx mme = new MailMessageEx();
                mme.To.Add(Recipient);
                mme.Subject = Subject;
                mme.Attachments.Add(att);
                mme.From = new MailAddress(FromAddress);
                Client.Send(mme);
            }
            catch (Exception ex)
            {
                ThrowException(new Exception("Не удалось отправить сообщение", ex));                
            }
        }

        public void SendMessage(string Recipient, string Subject, string AttName, XElement att)
        {
            SendMessage(new MailAddress(Recipient), Subject, new Attachment(
                    new MemoryStream(
                        Encoding.UTF8.GetBytes(att.ToString())), AttName, "text/xml"));
        }

        public void SendMessage(string Recipient, string Subject, string AttName, Stream att)
        {
            SendMessage(new MailAddress(Recipient), Subject, new Attachment(att, AttName, "text/xml"));
        }

        #region IWorkFrame Members

        

        #endregion
    }
}
